home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / program / recio212.zip / recio.c < prev    next >
C/C++ Source or Header  |  1995-01-29  |  15KB  |  411 lines
  1. /*****************************************************************************
  2.    MODULE: recio.c
  3.   PURPOSE: record input/output functions
  4. COPYRIGHT: (C) 1994-1995, William Pierpoint
  5.  COMPILER: Borland C Version 3.1
  6.        OS: MSDOS Version 6.2
  7.   VERSION: 2.12
  8.   RELEASE: January 29, 1995
  9. *****************************************************************************/
  10.  
  11. #include <ctype.h>
  12. #include <errno.h>
  13. #include <float.h>
  14. #include <limits.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. #include "recio.h"
  20.  
  21. #define rcol(rp)         ((rp)->r_colno)
  22. #define rflags(rp)       ((rp)->r_flags)
  23. #define rfd(rp)          ((rp)->r_fd)
  24. #define rfp(rp)          ((rp)->r_fp)
  25. #define rreclen(rp)      ((rp)->r_reclen)
  26. #define rrecsiz(rp)      ((rp)->r_recsiz)
  27. #define rfldsiz(rp)      ((rp)->r_fldsiz)
  28. #define rfldch(rp)       ((rp)->r_fldch)
  29. #define rtxtch(rp)       ((rp)->r_txtch)
  30. #define rtmfmt(rp)       ((rp)->r_tmfmt)
  31.  
  32. /* private module variables */
  33. static REC *_RECS = NULL;              /* ptr to array of RECs */
  34. static char _tmfmt[] = "%m/%d/%y";     /* default time format string */
  35.  
  36. static REC rin  = { 1,      0,    stdin,  "stdin",     0L,
  37.                     0,      0,        0,        0,   NULL, 
  38.                     0,   NULL, RECFLDCH, RECTXTCH,  _tmfmt, RECIN };
  39.  
  40. static REC rout = { 2, _R_WRT,   stdout, "stdout",     0L, 
  41.                     0,      0,        0,        0,   NULL, 
  42.                     0,   NULL, RECFLDCH, RECTXTCH, _tmfmt, RECOUT };
  43.  
  44. static REC rerr = { 3, _R_WRT,   stderr, "stderr",     0L, 
  45.                     0,      0,        0,        0,   NULL, 
  46.                     0,   NULL, RECFLDCH, RECTXTCH, _tmfmt, RECERR };
  47.  
  48. #if defined (__MSDOS__) || (MSDOS)
  49. static REC rprn = { 4, _R_WRT,   stdprn, "stdprn",     0L, 
  50.                     0,      0,        0,        0,   NULL, 
  51.                     0,   NULL, RECFLDCH, RECTXTCH, _tmfmt, RECPRN };
  52. #define NREC      4          /* number of static record streams */
  53. #else
  54. #define NREC      3
  55. #endif
  56.  
  57. #define ROPEN_MIN NREC       /* reserved for recin, etc */
  58. #define ROPEN     max(ROPEN_MAX, ROPEN_MIN)
  59.  
  60. /* public variables */
  61. REC *recin = &rin;
  62. REC *recout = &rout;
  63. REC *recerr = &rerr;
  64. #if defined (__MSDOS__) || (MSDOS)
  65. REC *recprn = &rprn;
  66. #endif
  67.  
  68. /* friend variables */
  69. char _r_nsbuf[NSBUFSIZ];     /* buffer for numeric to string conversions */
  70. void (*_r_errfn)(REC *);     /* pointer to error message function */
  71.  
  72. /* Support functions */
  73. /****************************************************************************/
  74. static void                  /* returns nothing                             */
  75.     _rexit(                  /* at program exit, clean up                   */
  76.         void)                /* no arguments                                */
  77. /****************************************************************************/
  78. {
  79.     /* free recin buffers */
  80.     free(rflds(recin));
  81.     free(rrecs(recin));
  82.     rflds(recin) = NULL;
  83.     rfldsiz(recin) = 0;
  84.     rrecs(recin) = NULL;
  85.     rrecsiz(recin) = 0;
  86.     rreclen(recin) = 0;
  87.  
  88.     /* ensure all record streams closed */
  89.     rcloseall();
  90. }
  91.  
  92. /****************************************************************************/
  93. void                         /* return error number (0=no error)            */
  94.     _rsetexitfn(             /* register _rexit function with atexit()      */
  95.         REC *rp)             /* record pointer                              */
  96. /****************************************************************************/
  97. {
  98.     static int once=0;       /* register exit fn only once */
  99.  
  100.     if (!once) {
  101.  
  102.         /* execute this path at most one time */
  103.         once++;
  104.  
  105.         /* if atexit() fails to register _rexit() function */
  106.         if (atexit(_rexit)) {
  107.  
  108.            /* register warning */
  109.            rsetwarn(rp, R_WNOREG);
  110.         }
  111.     }
  112. } 
  113.  
  114. /****************************************************************************/
  115. int                          /* return error number (0=no error)            */
  116.     _rmoderror(              /* check for mode error                        */
  117.         REC *rp,             /* record pointer                              */
  118.         int mode)            /* mode (0=read; !0=write/append)              */
  119. /****************************************************************************/
  120. {
  121.     int errnum=0;            /* error number (0=mode ok, !0=invalid mode) */
  122.     unsigned smode;          /* stream mode */
  123.  
  124.     /* if stream _R_WRT flag does not match mode */
  125.     smode = rflags(rp) & _R_WRT;
  126.     if ((mode && !smode) || (!mode && smode)) {
  127.         errnum = rseterr(rp, R_EINVMOD);
  128.     }
  129.     return errnum;
  130. }
  131.  
  132. /****************************************************************************/
  133. int                          /* return !0 if ready; 0 if in error state     */
  134.     _risready(               /* see if record stream is ready               */
  135.         REC *rp,             /* record pointer                              */
  136.         int mode)            /* mode (0=read; !0=write/append)              */
  137. /****************************************************************************/
  138. {
  139.     int errnum=0;            /* error number */
  140.  
  141.     /* test for valid record pointer */
  142.     if (!risvalid(rp)) {
  143.         errnum = rseterr(NULL, EINVAL);
  144.         goto done;
  145.     }
  146.     
  147.     /* check mode */
  148.     errnum = _rmoderror(rp, mode);
  149.     if (errnum) goto done;
  150.  
  151.     /* if record 0 and write mode, set record number to 1 */
  152.     if (!rrecno(rp) && mode) rrecno(rp)++;
  153.  
  154.     /* test for any previous error */
  155.     errnum = rerror(rp);
  156.  
  157. done:
  158.     return (!(errnum));
  159. }
  160.  
  161. /****************************************************************************/
  162. static void                  /* returns nothing                             */
  163.     _rfree(                  /* free the memory allocated to a record       */
  164.         REC *rp)             /* record pointer                              */
  165. /****************************************************************************/
  166. {
  167.     if (risvalid(rp)) {
  168.         free(rflds(rp));
  169.         free(rrecs(rp));
  170.         if (rfp(rp)) fclose(rfp(rp));
  171.         memset(rp, 0, sizeof(REC));
  172.     }
  173. }
  174.  
  175. /* User functions */
  176. /****************************************************************************/
  177. REC *                        /* return record pointer                       */
  178.     ropen(                   /* open a record stream for reading            */
  179.         const char *fname,   /* name of file to open                        */
  180.         const char *mode)    /* type of mode used to open file              */
  181. /****************************************************************************/
  182. {
  183.     REC *rp = _RECS;         /* record pointer */
  184.     int  i;                  /* count of REC structures */
  185.     int  ch;                 /* first character of mode */
  186.     
  187.     errno = 0;
  188.  
  189.     /* only modes currently supported are "r", "w", and "a" */
  190.     ch = tolower(*mode);
  191.     if (!(ch=='r' || ch=='w' || ch=='a')) {
  192.         rp = NULL;
  193.         rseterr(NULL, EINVAL);
  194.         goto done;
  195.     }
  196.  
  197.     /* allocate memory for array of REC structures */
  198.     if (!rp) {
  199.         do {
  200.             /* note: no memory allocation needed for recin, etc */
  201.             rp = _RECS = (REC *) calloc(ROPEN-NREC, sizeof(REC));
  202.             if (!rp) {
  203.                 if (rseterr(NULL, ENOMEM)) goto done;
  204.             }
  205.         } while (!rp);
  206.     }
  207.  
  208.     /* search thru REC structures until empty position found */
  209.     for (i=NREC+1; i <= ROPEN; i++, rp++) {
  210.         if (!rfd(rp)) {
  211.             rfd(rp) = i;
  212.             break;
  213.         }
  214.     }
  215.     /* error if out of positions */
  216.     if (i > ROPEN) {
  217.         rp = NULL;
  218.         rseterr(NULL, EMFILE);
  219.         goto done;
  220.     }
  221.  
  222.     /* open file */
  223.     rfp(rp) = fopen(fname, mode);
  224.     if (!rfp(rp)) {
  225.         rclose(rp);
  226.         rp = NULL;
  227.         /* if error other than path/file not found */
  228.         if (errno != ENOENT) {
  229.             rseterr(NULL, errno);
  230.         }
  231.         goto done;
  232.     }
  233.  
  234.     /* initialize */
  235.     rflags(rp)  = 0;
  236.     if (ch != 'r') rflags(rp) |= _R_WRT;
  237.     rnames(rp)  = fname;
  238.     rrecno(rp)  = 0L;
  239.     rfldno(rp)  = 0;
  240.     rcol(rp)    = 0;
  241.     rrecsiz(rp) = 0;
  242.     rreclen(rp) = 0;
  243.     rrecs(rp)   = NULL;
  244.     rfldsiz(rp) = 0;
  245.     rflds(rp)   = NULL;
  246.     rfldch(rp)  = RECFLDCH;
  247.     rtxtch(rp)  = RECTXTCH;
  248.     rtmfmt(rp) = _tmfmt;
  249.     rcxtno(rp) = 0;
  250.     _rsetexitfn(rp);
  251.  
  252. done:
  253.     return rp;
  254. }
  255.  
  256. /****************************************************************************/
  257. void                         /* returns nothing                             */
  258.     rclose(                  /* close a record stream                       */
  259.         REC *rp)             /* record pointer                              */
  260. /****************************************************************************/
  261. {
  262.     int i;                   /* count REC structures */
  263.     REC *recp=_RECS;         /* pointer to _RECS array */
  264.  
  265.     if (risvalid(rp)) {
  266.         /* close record stream, but not recin, recout, recerr */
  267.         if (rfd(rp) > NREC) _rfree(rp);
  268.  
  269.         /* if all record streams closed, free _RECS */
  270.         /* note: valid rp implies valid recp */
  271.         for (i=NREC+1; i <= ROPEN; i++, recp++) {
  272.             if (rfd(recp)) goto done;
  273.         }
  274.         free(_RECS);
  275.         _RECS = NULL;
  276.  
  277.     } else {
  278.         rseterr(NULL, EINVAL);
  279.     }
  280.  
  281. done:
  282. }
  283.  
  284. /****************************************************************************/
  285. int                          /* returns number of streams closed            */
  286.     rcloseall(               /* close all record streams                    */
  287.         void)                /* no arguments                                */
  288. /****************************************************************************/
  289. {
  290.     int num=0;               /* number of streams closed */
  291.     int i;                   /* count REC structures */
  292.     REC *recp=_RECS;         /* pointer to _RECS array */
  293.  
  294.     /* close every open record stream, except recin, etc */
  295.     if (recp) {
  296.         for (i=NREC+1; i <= ROPEN; i++, recp++) {
  297.             if (rfd(recp)) {
  298.                 _rfree(recp);
  299.                 num++;
  300.             }
  301.         }
  302.         free(_RECS);
  303.         _RECS = NULL;
  304.     }
  305.     return num;
  306. }
  307.  
  308. /****************************************************************************/
  309. int                          /* return !0 for valid; 0 for invalid          */
  310.     risvalid(                /* is record pointer valid?                    */
  311.         REC *rp)             /* record pointer                              */
  312. /****************************************************************************/
  313. {
  314.     int valid=1;             /* validation state (!0=valid) */
  315.  
  316.     /* if rp is null pointer or rfd not between 1 and ROPEN */
  317.     if (!rp || rfd(rp) < 1 || rfd(rp) > ROPEN) {
  318.         /* invalid record pointer */
  319.         valid = 0;
  320.     }
  321.     return valid;
  322. }
  323.  
  324. /****************************************************************************/
  325. void                         /* returns nothing                             */
  326.     rsetfldch(               /* set field separator character               */
  327.         REC *rp,             /* record pointer                              */
  328.         int  ch)             /* field separator character                   */
  329. /****************************************************************************/
  330. {
  331.     if (risvalid(rp)) {
  332.         if (isascii(ch)) {
  333.             rfldch(rp) = ch;
  334.         } else {
  335.             rseterr(rp, R_EINVAL);
  336.         }
  337.     } else {
  338.         rseterr(NULL, EINVAL);
  339.     }
  340. }
  341.  
  342. /****************************************************************************/
  343. void                         /* returns nothing                             */
  344.     rsettxtch(               /* set text string delimiter character         */
  345.         REC *rp,             /* record pointer                              */
  346.         int  ch)             /* text delimiter character                    */
  347. /****************************************************************************/
  348. {
  349.     if (risvalid(rp)) {
  350.         if (isascii(ch)) {
  351.             rtxtch(rp) = ch;
  352.         } else {
  353.             rseterr(rp, R_EINVAL);
  354.         }
  355.     } else {
  356.         rseterr(NULL, EINVAL);
  357.     }
  358. }
  359.  
  360. /****************************************************************************/
  361. void                         /* returns nothing                             */
  362.     rsettmfmt(               /* set time format string for record stream    */
  363.         REC *rp,             /* record pointer                              */
  364.         const char *fmt)     /* time format string                          */
  365. /****************************************************************************/
  366. {
  367.     if (risvalid(rp)) {
  368.         rtmfmt(rp) = fmt;
  369.     } else {
  370.         rseterr(NULL, EINVAL);
  371.     }
  372. }
  373.  
  374. /****************************************************************************/
  375. void                         /* returns nothing                             */
  376.     rsetcxtno(               /* set context number of record stream         */
  377.         REC *rp,             /* record pointer                              */
  378.         int  cxtno)          /* context number                              */
  379. /****************************************************************************/
  380. {
  381.     if (risvalid(rp)) {
  382.         if (rcxtno(rp) >= 0  && cxtno >= 0) {
  383.             rcxtno(rp) = cxtno;
  384.         } else {
  385.             rseterr(rp, R_EINVAL);
  386.         }
  387.     } else {
  388.         rseterr(NULL, EINVAL);
  389.     }
  390. }
  391.  
  392. /****************************************************************************/
  393. void                         /* returns nothing                             */
  394.     rsetbegcolno(            /* set beginning record column number          */
  395.         REC *rp,             /* record pointer                              */
  396.         int  colno)          /* first column in record is 0 or 1            */
  397. /****************************************************************************/
  398. {
  399.     if (risvalid(rp)) {
  400.         if (colno == 1) {
  401.             rflags(rp) |= _R_COL;
  402.         } else if (colno == 0) {
  403.             rflags(rp) &= ~_R_COL;
  404.         } else {
  405.             rseterr(rp, R_EINVAL);
  406.         }
  407.     } else {
  408.         rseterr(NULL, EINVAL);
  409.     }
  410. }
  411.